import axios from 'axios';
import $host from "./api";


axios.defaults.baseURL = $host + '/camera'

/**
 * 获取AccessToken
 */
export function _getAccessToken() {
    return axios({
        method: 'GET',
        url: '/accessToken'
    })
}

/**
 * 获取播放地址
 *
 * @param deviceSerial 设备序列号
 */
export function _getLiveAddress(deviceSerial: string) {
    return axios({
        method: 'GET',
        url: '/liveAddress',
        params: {
            deviceSerial: deviceSerial
        }
    })
}
/**
 * 添加设备
 *
 * @param accessToken  授权过程获取的access_token
 * @param deviceSerial 设备序列号,存在英文字母的设备序列号，字母需为大写
 * @param validateCode 设备验证码
 * @return
 */
export function _addDevice(accessToken: string,deviceSerial: string,validateCode: string) {
    return axios({
        method: 'Post',
        url: '/deviceAdd',
        params: {
            accessToken:accessToken,
            deviceSerial: deviceSerial,
            validateCode:validateCode
        }
    })
}

/**
 * 删除设备
 *
 * @param deviceSerial 设备序列号,存在英文字母的设备序列号，字母需为大写
 */
export function _deleteDevice(deviceSerial: string) {
    return axios({
        method: 'Post',
        url: '/deviceDelete',
        params: {
            deviceSerial: deviceSerial,
        }
    })
}

/**
 * 修改设备名
 *
 * @param deviceName   设备名称
 */
export function _updateName(deviceName: string) {
    return axios({
        method: 'Post',
        url: '/nameUpdate',
        params: {
            deviceSerial: deviceName,
        }
    })
}

/**
 * 获取设备列表
 *
 * @return void
 */
export function _queryDeviceList(accessToken: string) {
    return axios({
        method: 'Post',
        url: '/deviceList',
        params: {
            deviceSerial: accessToken,
        }
    })
}

/**
 * 获取单个设备信息
 *
 * @param deviceSerial 设备序列号,存在英文字母的设备序列号，字母需为大写
 */
export function _qgeQueryDeviceInfo(deviceSerial: string) {
    return axios({
        method: 'Post',
        url: '/deviceInfo',
        params: {
            deviceSerial: deviceSerial,
        }
    })
}

/**
 * 获取摄像头列表
 *
 */
export function _cameraList(accessToken: string) {
    return axios({
        method: 'Post',
        url: '/cameraList',
        params: {
            deviceSerial: accessToken,
        }
    })
}


/**
 * 获取设备状态信息
 *
 * @param deviceSerial 设备序列号,存在英文字母的设备序列号，字母需为大写
 */
export function getQueryDeviceStatus(deviceSerial: string) {
    return axios({
        method: 'Post',
        url: '/deviceStatus',
        params: {
            deviceSerial: deviceSerial,
        }
    })
}

/**
 * 获取指定设备的通道信息
 *
 * @param deviceSerial 设备序列号,存在英文字母的设备序列号，字母需为大写
 * @return
 */
export function _getChannelInfo(deviceSerial: string) {
    return axios({
        method: 'Post',
        url: '/deviceChannel',
        params: {
            deviceSerial: deviceSerial,
        }
    })
}

/**
 * 查询是否支持萤石云协议
 *
 * @param appKey      用户appKey : 9ff8c4b03a2f431584b55dcb3c20b6f1
 * @param model       设备型号 : CS-C1-10F
 * @param version     设备版本号 : V4.1.0 build 130101
 * @return
 */
export function _isSupportEzviz(appKey: string,model:String,version: String) {
    return axios({
        method: 'Post',
        url: '/supportEzviz',
        params: {
            appKey: appKey,
            model: model,
            version: version
        }
    })
}

/**
 * 获取摄像机指示灯开关状态
 *
 * @param deviceSerial 设备序列号,存在英文字母的设备序列号，字母需为大写
 * @return
 */
export function _getLightStatus(deviceSerial: string) {
    return axios({
        method: 'Post',
        url: '/lightStatus',
        params: {
            deviceSerial: deviceSerial
        }
    })
}


/**
 * 设置摄像机指示灯开关
 *
 * @param deviceSerial 设备序列号,存在英文字母的设备序列号，字母需为大写
 * @return
 */
export function _setLight(deviceSerial: string) {
    return axios({
        method: 'Post',
        url: '/lightSet',
        params: {
            deviceSerial: deviceSerial
        }
    })
}


/**
 * 获取全天录像开关状态
 *
 * @param deviceSerial 设备序列号,存在英文字母的设备序列号，字母需为大写
 * @return
 */
export function _getRecordStatus(deviceSerial: string) {
    return axios({
        method: 'Post',
        url: '/recordStatus',
        params: {
            deviceSerial: deviceSerial
        }
    })
}

/**
 * 设置全天录像开关
 *
 * @param deviceSerial 设备序列号,存在英文字母的设备序列号，字母需为大写
 * @return
 */
export function _setFulldayRecord(deviceSerial: string) {
    return axios({
        method: 'Post',
        url: '/fulldayRecordSet',
        params: {
            deviceSerial: deviceSerial
        }
    })
}


/**
 * 开始云台控制
 *
 * @param deviceSerial 设备序列号,存在英文字母的设备序列号，字母需为大写
 * @param direction    操作命令：-1-停止，0-上，1-下，2-左，3-右，4-左上，5-左下，6-右上，7-右下，8-放大，9-缩小，10-近焦距，11-远焦距
 */
export function _controlPtz(deviceSerial: string,
                            direction: number) {
    return axios({
        method: 'POST',
        url: '/controlPtz',
        params: {
            deviceSerial: deviceSerial,
            direction: direction,
        }
    })
}


/**
 * 停止云台转动
 *
 * @param deviceSerial 设备序列号,存在英文字母的设备序列号，字母需为大写
 * @param channelNo    通道号 1
 * @return
 */
export function _ptzStop(deviceSerial: string,
                         channelNo: number) {
    return axios({
        method: 'POST',
        url: '/ptzStop',
        params: {
            deviceSerial: deviceSerial,
            direction: channelNo,
        }
    })
}

/**
 * 添加预置点
 *
 * @param deviceSerial 设备序列号,存在英文字母的设备序列号，字母需为大写
 * @param channelNo    通道号
 * @return
 */
export function _addPreset(deviceSerial: string,
                         channelNo: number) {
    return axios({
        method: 'POST',
        url: '/presetAdd',
        params: {
            deviceSerial: deviceSerial,
            direction: channelNo,
        }
    })
}

/**
 * 删除预置点
 *
 * @param deviceSerial 设备序列号,存在英文字母的设备序列号，字母需为大写
 * @param channelNo    通道号
 * @return
 */
export function _clearPreset(deviceSerial: string,
                           channelNo: number) {
    return axios({
        method: 'POST',
        url: '/presetClear',
        params: {
            deviceSerial: deviceSerial,
            direction: channelNo,
        }
    })
}

/**
 * 调用预置点
 *
 * @param deviceSerial 设备序列号,存在英文字母的设备序列号，字母需为大写
 * @param channelNo    通道号
 * @return
 */
export function _movePreset(deviceSerial: string,
                             channelNo: number) {
    return axios({
        method: 'POST',
        url: '/presetMove',
        params: {
            deviceSerial: deviceSerial,
            direction: channelNo,
        }
    })
}


/**
 * 创建项目
 *
 * @param projectId   项目ID，项目的唯一标识，限制字母数字和下划线，长度在32位以内
 * @param projectName 项目名称，项目名称需要开发者在控制台自行创建，对应控制台的项目名称字段
 * @param expireDays  项目文件过期天数，0表示不过期，标准存储，不输入默认30天，归档存储，不输入默认60天，范围：0~36500天
 * @param storageType 项目存储类型，默认标准存储。1-标准存储,2-存档存储
 * @return
 */
export function _createProject(projectId: string,
                               projectName: number,
                               expireDays:number,
                               storageType:number,
                               flowLimit:number) {
    return axios({
        method: 'POST',
        url: '/createProject',
        params: {
            projectId: projectId,
            projectName: projectName,
            expireDays: expireDays,
            storageType: storageType,
            flowLimit: flowLimit
        }
    })
}


/**
 * 单条查询项目
 *
 * @param accessToken 用户令牌
 * @return
 */

export function _querySingleItem(projectId: string,
                               accessToken: String,
                               deviceSerial:String) {
    return axios({
        method: 'GET',
        url: '/querySingleItem',
        params: {
            projectId: projectId,
            accessToken: accessToken,
            deviceSerial: deviceSerial
        }
    })
}
/**
 * 分页查询项目
 * @param accessToken 用户令牌
 * @param pageNumber 分页查询页码, 以 0 开始,默认 0
 * @param pageSize 分页查询大小, 取值范围[1,20]，默认 10
 * @return
 */
export function _pagingQueryItem(accessToken: string,
                                 pageNumber: number,
                                 pageSize: number) {
    return axios({
        method: 'GET',
        url: '/pagingQueryItem',
        params: {
            accessToken: accessToken,
            pageNumber: pageNumber,
            pageSize: pageSize
        }
    })
}

/**
 * 更新项目
 * @param accessToken
 * @param projectName
 * @return
 */
export function _updateProject(accessToken: string,
                               projectName: string) {
    return axios({
        method: 'PUT',
        url: '/updateProject',
        params: {
            accessToken: accessToken,
            projectName: projectName
        }
    })
}

/**
 * 删除项目
 * @param projectName
 * @return
 */
export function _deleteProject(projectName: string) {
    return axios({
        method: 'DELETE',
        url: '/deleteProject',
        params: {
            projectName: projectName
        }
    })
}

////////////////////////////////任务接口////////////////////////////////////

/**
 * 单条查询文件信息
 * @return
 */
export function _querySingleFile(accessToken: string,
                                 fileId:String,
                                 projectId:String) {
    return axios({
        method: 'GET',
        url: '/querySingleFile',
        params: {
            accessToken: accessToken,
            fileId:fileId,
            projectId:projectId
        }
    })
}


/**
 * 分页查询文件详细信息
 *
 * @param accessToken 用户令牌
 * @param projectId   项目ID，项目的唯一标识，需输入已创建的项目ID
 * @param startTime   查询起始时间，若不传时间则默认当天，格式: yyyyMMddHHmmss
 * @param endTime     查询结束时间，若不传时间则默认当天，格式:yyyyMMddHHmmss
 * @param pageNumber  分页页码，以 0 开始，默认 0
 * @param pageSize    分页大小，取值范围[1,20]，默认 10
 * @return
 */
export function _pagingQueryFile(accessToken: string,
                                 projectId:String,
                                 startTime:String,
                                 endTime:String,
                                 pageNumber:number,
                                 pageSize:number) {
    return axios({
        method: 'GET',
        url: '/pagingQueryFile',
        params: {
            accessToken: accessToken,
            projectId:projectId,
            startTime:startTime,
            endTime:endTime,
            pageNumber:pageNumber,
            pageSize:pageSize
        }
    })
}

/**
 * 删除文件
 * @param accessToken 用户令牌
 * @param fileId  文件ID，项目下文件的唯一标识，需输入已录制的文件ID
 * @param projectId  项目ID，项目的唯一标识，需输入已创建的项目ID
 * @return
 */
export function _deleteFile(accessToken: string,
                            fileId:String,
                            projectId:String) {
    return axios({
        method: 'DELETE',
        url: '/deleteFile',
        params: {
            accessToken: accessToken,
            fileId:fileId,
            projectId:projectId
        }
    })
}


/**
 * 文件转移
 * @param accessToken accesToken
 * @param projectId  项目 ID，项目的唯一标识，需输入已创建的项目 ID
 * @param fileId 文件 ID，项目下文件的唯一标识，需输入已录制的文件 ID
 * @param newProjectId 要转移到的新项目 ID
 * @return
 */
export function _moveFile(accessToken: string,
                          projectId:String,
                          fileId:String,
                          newProjectId: String) {
    return axios({
        method: 'POST',
        url: '/moveFile',
        params: {
            accessToken: accessToken,
            projectId:projectId,
            fileId:fileId,
            newProjectId:newProjectId
        }
    })
}


/**
 * 获取文件下载/在线播放地址
 *
 * @param projectId 项目ID，项目的唯一标识，需输入已创建的项目ID
 * @param fileId    文件ID，项目下文件的唯一标识，需输入已录制的文件ID
 */
export function _obtainFileDownloadOrOnlinePlaybackAddress(projectId: string,
                                                           fileId: string) {
    return axios({
        method: 'GET',
        url: '/file/download',
        params: {
            projectId: projectId,
            fileId: fileId,
        }
    })
}

/**
 * 即时视频转码录制存储
 *
 * @param projectId     项目ID，项目的唯一标识，需输入已创建的项目ID
 * @param recordSeconds 录制时长,单位秒，默认86400秒（24小时）
 * @param validateCode  录像解密密钥， 若设备加密则必须填写，否则视频无法录制成功
 * @param sliceDuration 录像文件片段时长,单位分钟,默认30分钟
 * @param retryNum      任务重试次数,支持设置0-5次，默认不重试，不能超过5次
 * @param streamType    码流类型, 1-高清,2-标清，默认1
 * @param voiceSwitch   录制视频声音开关, 0.关 1.开 2.自动 默认2
 * @param devProto      设备协议：gb28181(国标),不传默认为萤石协议
 * @return
 */
export function _instantRecordSave(accessToken: string,
                                   deviceSerial:String,
                                   localIndex:String,
                                   projectId:String,
                                   recordSeconds:number,
                                   validateCode:String,
                                   sliceDuration:number,
                                   retryNum:number,
                                   streamType:number,
                                   voiceSwitch:number,
                                   devProto:String) {
    return axios({
        method: 'POST',
        url: '/instantRecordSave',
        params: {
            accessToken: accessToken,
            deviceSerial:deviceSerial,
            localIndex:localIndex,
            projectId:projectId,
            recordSeconds:recordSeconds,
            validateCode:validateCode,
            sliceDuration:sliceDuration,
            retryNum:retryNum,
            streamType:streamType,
            voiceSwitch:voiceSwitch,
            devProto:devProto
        }
    })
}


/**
 * 预约视频转码录制存储
 *
 * @param accessToken   授权过程获取的access_token
 * @param channelNo     录像文件片段时长，单位分钟，范围：30分钟-240分钟，默认30分钟
 * @param deviceSerial  设备序列号，由于转码限制，仅支持AAC 音频编码的设备有声录制
 * @param startTime     录像开始时间，格式: yyyyMMddHHmmss 开始时间需在未来 10 分钟后
 * @param endTime       录像结束时间，格式: yyyyMMddHHmmss 结束时间和开始时间之差需在 24 小时之内
 * @param projectId     项目ID，项目的唯一标识，需输入已创建的项目ID
 * @param validateCode  录像解密密钥， 若设备加密则必须填写，否则视频无法录制成功
 * @param voiceSwitch   录制视频声音开关，0.关 1.开 2.自动 默认 2，如果音频不是AAC，则自动关闭视频声音
 * @param devProto      若不传，则标识为萤石协议； 若传： gb28181 ，标识为国标设备 ；默认不传
 * @param streamType    码流类型，可以选择 1：高清（主码流） 2：标清（子码流）
 * @param aiBox         是否需要录制Ai框，0关 1开，默认关闭
 * @param sliceDuration 录像文件片段时长，单位分钟，范围：30分钟-240分钟，默认30分钟
 * @return
 */
export function _scheduleRecording(accessToken: string,
                                   channelNo:number,
                                   deviceSerial:String,
                                   startTime:String,
                                   endTime:number,
                                   projectId:String,
                                   validateCode:String,
                                   voiceSwitch:String,
                                   devProto:String,
                                   streamType:String,
                                   aiBox:String,
                                   sliceDuration,number) {
    return axios({
        method: 'POST',
        url: '/instantRecordSave',
        params: {
            accessToken: accessToken,
            channelNo:channelNo,
            deviceSerial:deviceSerial,
            startTime:startTime,
            endTime:endTime,
            projectId:projectId,
            validateCode:validateCode,
            voiceSwitch:voiceSwitch,
            devProto:devProto,
            streamType:streamType,
            aiBox:aiBox,
            sliceDuration:sliceDuration
        }
    })
}

/**
 * 抓图任务
 *
 * @param deviceSerial 设备序列号
 * @param projectId    项目ID，项目的唯一标识，需输入已创建的项目ID
 * @param captureType  抓图模式，抓拍类型，1:按时间点抓图 2:按时间间隔抓图
 * @param timingPoints 时间点列表，格式: yyyyMMddHHmmss,yyyyMMddHHmmss，时间点以英文逗号分隔，captureType==1 必填
 */
export function _capture(deviceSerial: string,
                         projectId:String,
                         captureType:number,
                         timingPoints:String,) {
    return axios({
        method: 'POST',
        url: '/capture',
        params: {
            deviceSerial: deviceSerial,
            projectId:projectId,
            captureType:captureType,
            timingPoints:timingPoints,
        }
    })
}


/**
 * 单日流量查询
 * @param accessToken 授权过程获取的access_token
 * @param flowTime      日期，时间格式为1457420564508，精确到毫秒，默认为当前日期往前1天。只能查询当前日期往前推算7天内、1天前的数据
 * @param pageStart 分页起始页，从0开始，默认为0
 * @param pageSize  分页大小，默认为10，最大为50
 * @return
 */
export function _dayFlow(accessToken: string,
                         flowTime:number,
                         pageStart:number,
                         pageSize:number,) {
    return axios({
        method: 'POST',
        url: '/dayFlow',
        params: {
            accessToken: accessToken,
            flowTime:flowTime,
            pageStart:pageStart,
            pageSize:pageSize
        }
    })
}


/**
 * 账户下总消耗量
 * @param accessToken 授权过程获取的access_token
 * @return
 */
export function _totalFlow(accessToken: string) {
    return axios({
        method: 'POST',
        url: '/totalFlow',
        params: {
            accessToken: accessToken,
        }
    })
}


/**
 * 流量消耗明细
 * @param accessToken 授权过程获取的access_token
 * @param startTime 开始时间，时间格式为1457420564508，精确到毫秒，默认为当前日期往前推算1周。最多只能查询当前日期往前1周内的数据
 * @param endTime 结束时间，时间格式为1457420564508，精确到毫秒，默认为当前日期往前推算1天。只能查询1天前的数据
 * @param pageStart 分页起始页，从0开始，默认为0
 * @param pageSize 分页大小，默认为10，最大为50
 * @return
 */
export function _flowDetail(accessToken: string,
                            startTime:number,
                            endTime:number,
                            pageStart:number,
                            pageSize:number) {
    return axios({
        method: 'POST',
        url: '/flowDetail',
        params: {
            accessToken: accessToken,
            startTime:startTime,
            endTime:endTime,
            pageStart:pageStart,
            pageSize:pageSize
        }
    })
}